import { observable, action, computed } from 'mobx-miniprogram';
import { cloudHelper, cacheHelper } from '../../helpers/index.js';
import pageHelper from '../../../helpers/page_helper.js';
import timeHelper from '../../../helpers/time_helper.js';
// 导入runInAction用于包装非action内的状态修改
import { runInAction } from 'mobx-miniprogram';

// 消息缓存配置
const MESSAGE_CACHE_KEY = 'MESSAGE_LIST';
const MESSAGE_CACHE_TIME = 3600; // 1小时过期

// 消息相关API路由
const MESSAGE_API = {
  LIST: 'home/dynamic_list',       // 获取消息列表
  READ: 'home/mark_read',          // 标记消息已读
  READ_ALL: 'home/mark_read_all',  // 标记所有消息已读
  DELETE: 'home/delete_message',   // 删除消息
  CLEAR: 'home/clear_messages'     // 清空所有消息
};

// 创建消息状态管理Store
export const messageStore = observable({
  // 消息列表数据
  messageList: [],
  
  // 是否还有更多数据
  hasMore: true,
  
  // 当前过滤模式
  filterMode: 'all', // all, unread, read
  
  // 加载状态
  loading: {
    messages: false,
    operation: false
  },
  
  // 初始化方法
  init: action(function() {
    // 从缓存加载消息列表
    try {
      const cachedMessages = cacheHelper.get(MESSAGE_CACHE_KEY);
      
      // 确保缓存数据是数组
      if (cachedMessages && Array.isArray(cachedMessages) && cachedMessages.length > 0) {
        this.messageList = cachedMessages;
      } else {
        // 确保messageList是空数组而不是undefined或null
        this.messageList = [];
      }
    } catch (error) {
      console.error('读取消息缓存失败:', error);
      this.messageList = [];
    }
    
    // 异步获取最新消息
    setTimeout(() => {
      this.refreshUnreadCount().catch(err => {
        console.error('初始化时刷新未读消息数量失败:', err);
      });
    }, 500);
  }),
  
  // 计算属性：获取未读消息数量
  get unreadCount() {
    return this.messageList.filter(msg => msg.status === 'unread').length;
  },
  
  // 别名属性：兼容旧代码中使用的list属性
  get list() {
    return this.messageList;
  },
  
  // 别名属性：兼容旧代码
  get filteredList() {
    return this.filteredMessageList;
  },
  
  // 计算属性：根据过滤模式获取过滤后的消息列表
  get filteredMessageList() {
    if (this.filterMode === 'all') return this.messageList;
    if (this.filterMode === 'unread') return this.messageList.filter(msg => msg.status === 'unread');
    if (this.filterMode === 'read') return this.messageList.filter(msg => msg.status === 'read');
    return this.messageList;
  },
  
  // 设置过滤模式
  setFilterMode: action(function(mode) {
    this.filterMode = mode;
  }),
  
  // 加载消息列表
  loadMessageList: action(async function(skip = 0) {
    if (this.loading.messages) return;
    
    try {
      this.loading.messages = true;
      
      // 如果是初次加载且有缓存，先使用缓存数据
      if (skip === 0) {
        const cachedMessages = cacheHelper.get(MESSAGE_CACHE_KEY);
        if (cachedMessages && cachedMessages.length > 0) {
          this.messageList = cachedMessages;
          // 异步更新，但先展示缓存数据
          this._fetchAndUpdateMessages(skip);
          return;
        }
      }
      
      await this._fetchAndUpdateMessages(skip);
    } catch (e) {
      console.error('加载消息列表失败:', e);
    } finally {
      runInAction(() => {
        this.loading.messages = false;
      });
    }
  }),
  
  // 添加loadList作为loadMessageList的别名，以兼容旧代码
  loadList: action(async function(refresh = false) {
    return this.loadMessageList(refresh ? 0 : this.messageList.length);
  }),
  
  // 标记消息为已读，兼容API
  markAsRead: action(async function(messageId) {
    return this.markMessageAsRead(messageId);
  }),
  
  // 获取并更新消息列表
  _fetchAndUpdateMessages: action(async function(skip = 0) {
    try {
      const opts = { title: 'bar' };
      let result;
      
      try {
        result = await cloudHelper.callCloudData(MESSAGE_API.LIST, { 
          skip, 
          limit: 10
        }, opts);
      } catch (apiError) {
        console.error('调用动态列表API失败:', apiError);
        return [];
      }
      
      // 添加调试日志
      console.log('动态列表API返回数据:', result);
      
      // 基础有效性校验，确保result和result.data存在
      if (!result) {
        console.error('API返回结果为空');
        return [];
      }
      
      if (result.data === undefined || result.data === null) {
        console.error('API返回数据缺少data字段:', result);
        return [];
      }
      
      // 记录嵌套data字段结构
      if (result.data && result.data.data) {
        console.log('嵌套data结构:', result.data.data);
      }
      
      // 处理不同的数据结构可能性
      let messageArray = [];
      
      try {
        // 检查空对象情况
        if (!result.data || Object.keys(result.data).length === 0) {
          console.log('API返回空对象，视为空消息列表');
          messageArray = [];
        } else if (Array.isArray(result.data)) {
          // 如果data直接是数组
          messageArray = result.data;
        } else if (result.data.list && Array.isArray(result.data.list)) {
          // 如果data是包含list数组的对象
          messageArray = result.data.list;
        } else if (result.data.result && Array.isArray(result.data.result)) {
          // 如果data是包含result数组的对象
          messageArray = result.data.result;
        } else if (result.data.items && Array.isArray(result.data.items)) {
          // 如果data是包含items数组的对象
          messageArray = result.data.items;
        } else if (result.data.data) {
          // 处理嵌套data字段的情况
          if (Array.isArray(result.data.data)) {
            // 如果data.data直接是数组
            messageArray = result.data.data;
          } else if (result.data.data.list && Array.isArray(result.data.data.list)) {
            // 如果data.data包含list数组
            messageArray = result.data.data.list;
          } else if (result.data.data.result && Array.isArray(result.data.data.result)) {
            // 如果data.data包含result数组
            messageArray = result.data.data.result;
          } else if (result.data.data.items && Array.isArray(result.data.data.items)) {
            // 如果data.data包含items数组
            messageArray = result.data.data.items;
          } else {
            // 如果data.data存在但没识别出数组，记录结构并返回空数组
            console.error('嵌套data字段无法识别的结构:', result.data.data);
            // 强制返回空数组
            messageArray = [];
          }
        } else {
          // 如果没有找到数组，返回空数组
          console.error('无法识别的消息数据结构:', result.data);
          // 返回空数组
          messageArray = [];
        }
      } catch (parseError) {
        console.error('解析消息数据结构出错:', parseError);
        messageArray = [];
      }
      
      // 确保messageArray是数组
      if (!Array.isArray(messageArray)) {
        console.error('处理后的messageArray不是数组，强制转为空数组');
        messageArray = [];
      }
      
      // 如果最终没有获取到数组或数组为空，返回空结果
      if (!messageArray || messageArray.length === 0) {
        console.log('消息列表为空');
        
        // 如果是刷新（skip=0），则更新为空数组；如果是加载更多，则不更新
        if (skip === 0) {
          runInAction(() => {
            this.messageList = [];
            this.hasMore = false;
          });
          
          // 更新缓存
          cacheHelper.set(MESSAGE_CACHE_KEY, [], MESSAGE_CACHE_TIME);
        }
        
        return [];
      }
      
      // 转换消息数据格式
      const messages = messageArray.map(item => {
        try {
          // 如果item为null或非对象，返回默认消息对象
          if (!item || typeof item !== 'object') {
            console.warn('消息项无效:', item);
            return {
              _id: Date.now() + Math.random().toString(36).substring(2, 8),
              title: '系统通知',
              content: '无效消息',
              status: 'unread',
              time: timeHelper.fmtDateTimeShow(Date.now()),
              addTime: Date.now()
            };
          }
          
          return {
            _id: item._id || item.id || Date.now() + Math.random().toString(36).substring(2, 8),
            title: item.TITLE || item.title || '消息通知',
            content: item.CONTENT || item.content || '',
            status: item.STATUS || item.status || 'unread',
            time: timeHelper.fmtDateTimeShow(item.ADD_TIME || item.addTime || item.time) || '',
            url: item.URL || item.url || '',
            addTime: item.ADD_TIME || item.addTime || item.time || ''
          };
        } catch (itemError) {
          console.error('处理消息项出错:', itemError, item);
          // 返回一个默认的消息对象
          return {
            _id: Date.now() + Math.random().toString(36).substring(2, 8),
            title: '系统通知',
            content: '消息解析错误',
            status: 'unread',
            time: timeHelper.fmtDateTimeShow(Date.now()),
            addTime: Date.now()
          };
        }
      });
      
      // 使用runInAction确保更新messageList是在事务中
      runInAction(() => {
        // 更新消息列表
        if (skip === 0) {
          this.messageList = messages;
        } else {
          this.messageList = [...this.messageList, ...messages];
        }
        
        // 更新是否还有更多数据
        this.hasMore = messages.length === 10;
      });
      
      // 只使用cacheHelper进行缓存，不再直接使用wx.setStorageSync
      if (skip === 0) {
        cacheHelper.set(MESSAGE_CACHE_KEY, this.messageList, MESSAGE_CACHE_TIME);
      }
      
      return this.messageList;
    } catch (e) {
      console.error('获取消息列表失败:', e);
      return [];
    }
  }),
  
  // 标记消息为已读
  markMessageAsRead: action(async function(messageId) {
    if (!messageId || this.loading.operation) return false;
    
    try {
      this.loading.operation = true;
      
      // 先更新本地状态，再异步更新服务端
      const index = this.messageList.findIndex(msg => msg._id === messageId);
      if (index >= 0 && this.messageList[index].status === 'unread') {
        runInAction(() => {
          this.messageList[index].status = 'read';
        });
        
        // 调用接口更新服务端
        const opts = { title: 'bar' };
        const result = await cloudHelper.callCloudData(MESSAGE_API.READ, { id: messageId }, opts);
        
        if (result && result.data) {
          // 只使用cacheHelper更新缓存
          cacheHelper.set(MESSAGE_CACHE_KEY, this.messageList, MESSAGE_CACHE_TIME);
          
          return true;
        }
        
        // 如果服务端更新失败，恢复状态
        runInAction(() => {
          this.messageList[index].status = 'unread';
        });
        return false;
      }
      
      return false;
    } catch (e) {
      console.error('标记消息已读失败:', e);
      return false;
    } finally {
      runInAction(() => {
        this.loading.operation = false;
      });
    }
  }),
  
  // 标记所有消息为已读
  markAllAsRead: action(async function() {
    if (this.loading.operation || this.unreadCount === 0) return false;
    
    try {
      this.loading.operation = true;
      
      // 先更新本地状态，再异步更新服务端
      const originalMessages = [...this.messageList];
      
      // 更新所有未读消息为已读
      runInAction(() => {
        this.messageList.forEach(msg => {
          if (msg.status === 'unread') {
            msg.status = 'read';
          }
        });
      });
      
      // 调用接口更新服务端
      const opts = { title: '处理中' };
      const result = await cloudHelper.callCloudData(MESSAGE_API.READ_ALL, {}, opts);
      
      if (result && result.data) {
        // 只使用cacheHelper更新缓存
        cacheHelper.set(MESSAGE_CACHE_KEY, this.messageList, MESSAGE_CACHE_TIME);
        
        return true;
      }
      
      // 如果服务端更新失败，恢复状态
      runInAction(() => {
        this.messageList = originalMessages;
      });
      return false;
    } catch (e) {
      console.error('标记所有已读失败:', e);
      return false;
    } finally {
      runInAction(() => {
        this.loading.operation = false;
      });
    }
  }),
  
  // 刷新未读消息数量
  refreshUnreadCount: action(async function() {
    try {
      // 避免重复加载
      if (this.loading.messages) return 0;
      
      // 简单调用一次消息列表加载（只获取首页数据）
      await this.loadMessageList(0);
      
      return this.unreadCount;
    } catch (e) {
      console.error('刷新未读消息数量失败:', e);
      // 即使失败也返回当前缓存的未读数
      return this.unreadCount;
    }
  }),
  
  // 删除消息
  deleteMessage: action(async function(messageId) {
    if (!messageId || this.loading.operation) return false;
    
    try {
      this.loading.operation = true;
      
      // 先更新本地状态，再异步更新服务端
      const index = this.messageList.findIndex(msg => msg._id === messageId);
      if (index >= 0) {
        const originalMessages = [...this.messageList];
        
        runInAction(() => {
          this.messageList.splice(index, 1);
        });
        
        // 调用接口更新服务端
        const opts = { title: 'bar' };
        const result = await cloudHelper.callCloudData(MESSAGE_API.DELETE, { id: messageId }, opts);
        
        if (result && result.data) {
          // 只使用cacheHelper更新缓存
          cacheHelper.set(MESSAGE_CACHE_KEY, this.messageList, MESSAGE_CACHE_TIME);
          
          return true;
        }
        
        // 如果服务端更新失败，恢复状态
        runInAction(() => {
          this.messageList = originalMessages;
        });
        return false;
      }
      
      return false;
    } catch (e) {
      console.error('删除消息失败:', e);
      return false;
    } finally {
      runInAction(() => {
        this.loading.operation = false;
      });
    }
  }),
  
  // 清空所有消息
  clearMessages: action(async function() {
    if (this.loading.operation || this.messageList.length === 0) return false;
    
    try {
      this.loading.operation = true;
      
      // 保存原始消息，以便恢复
      const originalMessages = [...this.messageList];
      
      // 清空消息列表
      runInAction(() => {
        this.messageList = [];
      });
      
      // 调用接口清空服务端消息
      const opts = { title: '处理中' };
      const result = await cloudHelper.callCloudData(MESSAGE_API.CLEAR, {}, opts);
      
      if (result && result.data) {
        // 更新缓存
        cacheHelper.set(MESSAGE_CACHE_KEY, [], MESSAGE_CACHE_TIME);
        
        return true;
      }
      
      // 恢复原始消息
      runInAction(() => {
        this.messageList = originalMessages;
      });
      return false;
    } catch (e) {
      console.error('清空消息失败:', e);
      return false;
    } finally {
      runInAction(() => {
        this.loading.operation = false;
      });
    }
  }),
  
  // 获取未读消息数量 - 提供外部调用
  getUnreadCount: function() {
    return this.unreadCount;
  },
  
  // 清除消息缓存
  clearCache: action(function() {
    cacheHelper.remove(MESSAGE_CACHE_KEY);
  })
}); 